package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade PONTO_PLANO_EXECUCAO
 * @author Gerado pelo Telescope
 */
public class EntPontoPlanoExecucao extends AssociativeEntity {
    
    public final static String ENTITY_NAME = "ZTEST.PONTO_PLANO_EXECUCAO";
    public final static String TABLE_NAME = "PONTO_PLANO_EXECUCAO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntPontoPlanoExecucao() {
        super();
        initialize();
    }
    
    public EntPontoPlanoExecucao(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aPlanoExecucaoId = new DomId(this,"PLANO_EXECUCAO_ID", "Plano de execução"); 
        aPlanoExecucaoId.setRequired(true);
        oPlanoExecucaoId = new DomId();
        aPontoExecucaoAnteriorId = new DomId(this,"PONTO_EXECUCAO_ANTERIOR_ID", "Ponto de execução anterior"); 
        oPontoExecucaoAnteriorId = new DomId();
        aQuantidadeIteracoesPonto = new DomInteger(this,"QUANTIDADE_ITERACOES_PONTO", "Quantidade de iterações neste ponto"); 
        aQuantidadeIteracoesPonto.setRequired(true);
        aQuantidadeIteracoesPonto.setDefaultValue("1");
        oQuantidadeIteracoesPonto = new DomInteger();
        aPontoExecucaoId = new DomId(this,"PONTO_EXECUCAO_ID", "Ponto de execução"); 
        aPontoExecucaoId.setRequired(true);
        oPontoExecucaoId = new DomId();
        aFormulaCalcularVazaoId = new DomId(this,"FORMULA_CALCULAR_VAZAO_ID", "Fórmula para calcular a vazão"); 
        oFormulaCalcularVazaoId = new DomId();
        aSequencia = new DomInteger(this,"SEQUENCIA", "Sequência"); 
        aSequencia.setRequired(true);
        oSequencia = new DomInteger();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Plano de execução
    private DomId aPlanoExecucaoId;
    private DomId oPlanoExecucaoId;
    
    // Ponto de execução anterior
    private DomId aPontoExecucaoAnteriorId;
    private DomId oPontoExecucaoAnteriorId;
    
    // Quantidade de iterações neste ponto
    private DomInteger aQuantidadeIteracoesPonto;
    private DomInteger oQuantidadeIteracoesPonto;
    
    // Ponto de execução
    private DomId aPontoExecucaoId;
    private DomId oPontoExecucaoId;
    
    // Fórmula para calcular a vazão
    private DomId aFormulaCalcularVazaoId;
    private DomId oFormulaCalcularVazaoId;
    
    // Sequência
    private DomInteger aSequencia;
    private DomInteger oSequencia;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntPontoPlanoExecucao id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PLANO_EXECUCAO_ID">
    
    public EntPontoPlanoExecucao planoExecucaoId(Long value) {
        setPlanoExecucaoId(value);
        return this;
    }
    
    public void setPlanoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value.getValue());
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(String value) {
        if (value == null) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value);
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(Long value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPlanoExecucaoId(Object value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPlanoExecucaoId() {
        if (!aPlanoExecucaoId.isNull()) {
            aPlanoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPlanoExecucaoId() {
        return aPlanoExecucaoId;
    }
    
    public DomId oldPlanoExecucaoId() {
        return oPlanoExecucaoId;
    }
    
    public Long valueOfPlanoExecucaoId() {
        return aPlanoExecucaoId.getValue();
    }
    
    public boolean isPlanoExecucaoIdModified() {
        return aPlanoExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PONTO_EXECUCAO_ANTERIOR_ID">
    
    public EntPontoPlanoExecucao pontoExecucaoAnteriorId(Long value) {
        setPontoExecucaoAnteriorId(value);
        return this;
    }
    
    public void setPontoExecucaoAnteriorId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPontoExecucaoAnteriorId();
        } else {
            aPontoExecucaoAnteriorId.setValue(value.getValue());
            if (aPontoExecucaoAnteriorId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoExecucaoAnteriorId(String value) {
        if (value == null) {
            nullifyPontoExecucaoAnteriorId();
        } else {
            aPontoExecucaoAnteriorId.setValue(value);
            if (aPontoExecucaoAnteriorId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoExecucaoAnteriorId(Long value) {
        aPontoExecucaoAnteriorId.setValue(value);
        if (aPontoExecucaoAnteriorId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPontoExecucaoAnteriorId(Object value) {
        aPontoExecucaoAnteriorId.setValue(value);
        if (aPontoExecucaoAnteriorId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPontoExecucaoAnteriorId() {
        if (!aPontoExecucaoAnteriorId.isNull()) {
            aPontoExecucaoAnteriorId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPontoExecucaoAnteriorId() {
        return aPontoExecucaoAnteriorId;
    }
    
    public DomId oldPontoExecucaoAnteriorId() {
        return oPontoExecucaoAnteriorId;
    }
    
    public Long valueOfPontoExecucaoAnteriorId() {
        return aPontoExecucaoAnteriorId.getValue();
    }
    
    public boolean isPontoExecucaoAnteriorIdModified() {
        return aPontoExecucaoAnteriorId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_ITERACOES_PONTO">
    
    public EntPontoPlanoExecucao quantidadeIteracoesPonto(Integer value) {
        setQuantidadeIteracoesPonto(value);
        return this;
    }
    
    public void setQuantidadeIteracoesPonto(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeIteracoesPonto();
        } else {
            aQuantidadeIteracoesPonto.setValue(value.getValue());
            if (aQuantidadeIteracoesPonto.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeIteracoesPonto(String value) {
        if (value == null) {
            nullifyQuantidadeIteracoesPonto();
        } else {
            aQuantidadeIteracoesPonto.setValue(value);
            if (aQuantidadeIteracoesPonto.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeIteracoesPonto(Integer value) {
        aQuantidadeIteracoesPonto.setValue(value);
        if (aQuantidadeIteracoesPonto.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeIteracoesPonto(Object value) {
        aQuantidadeIteracoesPonto.setValue(value);
        if (aQuantidadeIteracoesPonto.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeIteracoesPonto() {
        if (!aQuantidadeIteracoesPonto.isNull()) {
            aQuantidadeIteracoesPonto.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeIteracoesPonto() {
        return aQuantidadeIteracoesPonto;
    }
    
    public DomInteger oldQuantidadeIteracoesPonto() {
        return oQuantidadeIteracoesPonto;
    }
    
    public Integer valueOfQuantidadeIteracoesPonto() {
        return aQuantidadeIteracoesPonto.getValue();
    }
    
    public boolean isQuantidadeIteracoesPontoModified() {
        return aQuantidadeIteracoesPonto.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PONTO_EXECUCAO_ID">
    
    public EntPontoPlanoExecucao pontoExecucaoId(Long value) {
        setPontoExecucaoId(value);
        return this;
    }
    
    public void setPontoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPontoExecucaoId();
        } else {
            aPontoExecucaoId.setValue(value.getValue());
            if (aPontoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoExecucaoId(String value) {
        if (value == null) {
            nullifyPontoExecucaoId();
        } else {
            aPontoExecucaoId.setValue(value);
            if (aPontoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoExecucaoId(Long value) {
        aPontoExecucaoId.setValue(value);
        if (aPontoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPontoExecucaoId(Object value) {
        aPontoExecucaoId.setValue(value);
        if (aPontoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPontoExecucaoId() {
        if (!aPontoExecucaoId.isNull()) {
            aPontoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPontoExecucaoId() {
        return aPontoExecucaoId;
    }
    
    public DomId oldPontoExecucaoId() {
        return oPontoExecucaoId;
    }
    
    public Long valueOfPontoExecucaoId() {
        return aPontoExecucaoId.getValue();
    }
    
    public boolean isPontoExecucaoIdModified() {
        return aPontoExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FORMULA_CALCULAR_VAZAO_ID">
    
    public EntPontoPlanoExecucao formulaCalcularVazaoId(Long value) {
        setFormulaCalcularVazaoId(value);
        return this;
    }
    
    public void setFormulaCalcularVazaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyFormulaCalcularVazaoId();
        } else {
            aFormulaCalcularVazaoId.setValue(value.getValue());
            if (aFormulaCalcularVazaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaCalcularVazaoId(String value) {
        if (value == null) {
            nullifyFormulaCalcularVazaoId();
        } else {
            aFormulaCalcularVazaoId.setValue(value);
            if (aFormulaCalcularVazaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaCalcularVazaoId(Long value) {
        aFormulaCalcularVazaoId.setValue(value);
        if (aFormulaCalcularVazaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setFormulaCalcularVazaoId(Object value) {
        aFormulaCalcularVazaoId.setValue(value);
        if (aFormulaCalcularVazaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFormulaCalcularVazaoId() {
        if (!aFormulaCalcularVazaoId.isNull()) {
            aFormulaCalcularVazaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getFormulaCalcularVazaoId() {
        return aFormulaCalcularVazaoId;
    }
    
    public DomId oldFormulaCalcularVazaoId() {
        return oFormulaCalcularVazaoId;
    }
    
    public Long valueOfFormulaCalcularVazaoId() {
        return aFormulaCalcularVazaoId.getValue();
    }
    
    public boolean isFormulaCalcularVazaoIdModified() {
        return aFormulaCalcularVazaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA">
    
    public EntPontoPlanoExecucao sequencia(Integer value) {
        setSequencia(value);
        return this;
    }
    
    public void setSequencia(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifySequencia();
        } else {
            aSequencia.setValue(value.getValue());
            if (aSequencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequencia(String value) {
        if (value == null) {
            nullifySequencia();
        } else {
            aSequencia.setValue(value);
            if (aSequencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequencia(Integer value) {
        aSequencia.setValue(value);
        if (aSequencia.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequencia(Object value) {
        aSequencia.setValue(value);
        if (aSequencia.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequencia() {
        if (!aSequencia.isNull()) {
            aSequencia.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getSequencia() {
        return aSequencia;
    }
    
    public DomInteger oldSequencia() {
        return oSequencia;
    }
    
    public Integer valueOfSequencia() {
        return aSequencia.getValue();
    }
    
    public boolean isSequenciaModified() {
        return aSequencia.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PONTO_PLANO_EXECUCAO
        {
            EntRegraVariavelPlanoExecucao external = new EntRegraVariavelPlanoExecucao(ctx);
            external.findByPontoPlanoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PONTO_PLANO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Regras para os valores de variáveis nos planos de execuções fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_PONTO_PLANO_EXECUCAO
        {
            EntValorVariavelEnsaio external = new EntValorVariavelEnsaio(ctx);
            external.findByPontoPlanoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_PONTO_PLANO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Valores das variávéis nos ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_ANTERIOR
        {
            EntPontoPlanoExecucao external = new EntPontoPlanoExecucao(ctx);
            external.findByPontoExecucaoAnterior(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_ANTERIOR.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Pontos utilizados nos planos de execuções fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_RGVVPE_PONTO_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PONTO_PLANO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Regras para os valores de variáveis nos planos de execuções fazendo referencia para este registro! (FK_RGVVPE_PONTO_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_VAVAEN_PONTO_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_PONTO_PLANO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Valores das variávéis nos ensaios fazendo referencia para este registro! (FK_VAVAEN_PONTO_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_PUNPEX_PONTO_ANTERIOR") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_ANTERIOR.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Pontos utilizados nos planos de execuções fazendo referencia para este registro! (FK_PUNPEX_PONTO_ANTERIOR)");
                return e;
            } else {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("UK_PUNPEX_SEQUENCIA") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.UK_PUNPEX_SEQUENCIA", 
                        Severity.ERROR,
                        "Registro duplicado! Sequência do ponto no plano deve ser único Plano de execução ${PLANO_EXECUCAO_ID}, Sequência ${SEQUENCIA} (UK_PUNPEX_SEQUENCIA)");
                return e;
            } else if (msg.indexOf("UK_PUNPEX_PONTO_PLANO") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.UK_PUNPEX_PONTO_PLANO", 
                        Severity.ERROR,
                        "Registro duplicado! Ponto deve ser única para o mesmo plano. Plano de execução ${PLANO_EXECUCAO_ID}, Ponto de execução ${PONTO_EXECUCAO_ID} (UK_PUNPEX_PONTO_PLANO)");
                return e;
            } else if (msg.indexOf("FK_PUNPEX_FORMULA") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_FORMULA", 
                        Severity.ERROR,
                        "Registro não cadastrado para FORMULA_CALCULAR_VAZAO! (FK_PUNPEX_FORMULA)");
                return e;
            } else if (msg.indexOf("FK_PUNPEX_PONTO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PONTO_EXECUCAO! (FK_PUNPEX_PONTO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_PUNPEX_PONTO_ANTERIOR") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_ANTERIOR", 
                        Severity.ERROR,
                        "Registro não cadastrado para PONTO_EXECUCAO_ANTERIOR! (FK_PUNPEX_PONTO_ANTERIOR)");
                return e;
            } else if (msg.indexOf("FK_PUNPEX_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PLANO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PLANO_EXECUCAO! (FK_PUNPEX_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("PK_PUNPEX") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.PK_PUNPEX", 
                        Severity.ERROR,
                        "ID duplicado! (PK_PUNPEX)");
                return e;
            } else {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aPlanoExecucaoId);
            allAttributes.add(aPontoExecucaoAnteriorId);
            allAttributes.add(aQuantidadeIteracoesPonto);
            allAttributes.add(aPontoExecucaoId);
            allAttributes.add(aFormulaCalcularVazaoId);
            allAttributes.add(aSequencia);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getPlanoExecucaoId().toString() +
                " " + getPontoExecucaoId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    /**
     * Métodos de manipulação dos IDs das entidades associadas
     */
    public DomId getAssociationId1() {
        return getPlanoExecucaoId();
    }
    public DomId getAssociationId2() {
        return getPontoExecucaoId();
    }
    public void setAssociationId1(long id) {
        setPlanoExecucaoId(id);
    }
    public void setAssociationId2(long id) {
        setPontoExecucaoId(id);
    }
    
    public void findByPlanoExecucaoIdPontoExecucaoId(long planoExecucaoId, long pontoExecucaoId) throws AdsException {
        findBy(new String[] {"PLANO_EXECUCAO_ID", "PONTO_EXECUCAO_ID"},
                new Object[] {planoExecucaoId, pontoExecucaoId});
    }
    
    public void findByPlanoExecucaoIdSequencia(long planoExecucaoId, int sequencia) throws AdsException {
        findBy(new String[] {"PLANO_EXECUCAO_ID", "SEQUENCIA"},
                new Object[] {planoExecucaoId, sequencia});
    }
    
    private EntFormulaExecucao eFormulaCalcularVazao;
    
    public EntFormulaExecucao findFormulaCalcularVazao() throws AdsException {
        if (getFormulaCalcularVazaoId().isNull()) {
            return null;
        }
        if (eFormulaCalcularVazao == null || !valueOfFormulaCalcularVazaoId().equals(eFormulaCalcularVazao.valueOfId())) {
            eFormulaCalcularVazao = new EntFormulaExecucao(ctx);
            eFormulaCalcularVazao.find(valueOfFormulaCalcularVazaoId());
        }
        return eFormulaCalcularVazao;
    }
    
    /**
     * Ativa o join desta entidade com FORMULA_EXECUCAO
     * através do atributo FORMULA_CALCULAR_VAZAO_ID
     */
    public EntFormulaExecucao joinFormulaCalcularVazao() {
        return joinFormulaCalcularVazao(null);
    }
    public EntFormulaExecucao joinFormulaCalcularVazao(String alias) {
        EntFormulaExecucao entity = new EntFormulaExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getFormulaCalcularVazaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByFormulaCalcularVazao(long id, String sqlAppend) throws AdsException {
        find("select ID from PONTO_PLANO_EXECUCAO where FORMULA_CALCULAR_VAZAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByFormulaCalcularVazao(long id) throws AdsException {
        findByFormulaCalcularVazao(id,"");
    }
    
    public void findByFormulaCalcularVazao(Entity entidade) throws AdsException {
        findByFormulaCalcularVazao(entidade.valueOfId(),"");
    }
    
    public void findByFormulaCalcularVazao(Entity entidade, String sqlAppend) throws AdsException {
        findByFormulaCalcularVazao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPontoExecucao ePontoExecucao;
    
    public EntPontoExecucao findPontoExecucao() throws AdsException {
        if (getPontoExecucaoId().isNull()) {
            return null;
        }
        if (ePontoExecucao == null || !valueOfPontoExecucaoId().equals(ePontoExecucao.valueOfId())) {
            ePontoExecucao = new EntPontoExecucao(ctx);
            ePontoExecucao.find(valueOfPontoExecucaoId());
        }
        return ePontoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PONTO_EXECUCAO
     * através do atributo PONTO_EXECUCAO_ID
     */
    public EntPontoExecucao joinPontoExecucao() {
        return joinPontoExecucao(null);
    }
    public EntPontoExecucao joinPontoExecucao(String alias) {
        EntPontoExecucao entity = new EntPontoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPontoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPontoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from PONTO_PLANO_EXECUCAO where PONTO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPontoExecucao(long id) throws AdsException {
        findByPontoExecucao(id,"");
    }
    
    public void findByPontoExecucao(Entity entidade) throws AdsException {
        findByPontoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPontoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPontoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPontoPlanoExecucao ePontoExecucaoAnterior;
    
    public EntPontoPlanoExecucao findPontoExecucaoAnterior() throws AdsException {
        if (getPontoExecucaoAnteriorId().isNull()) {
            return null;
        }
        if (ePontoExecucaoAnterior == null || !valueOfPontoExecucaoAnteriorId().equals(ePontoExecucaoAnterior.valueOfId())) {
            ePontoExecucaoAnterior = new EntPontoPlanoExecucao(ctx);
            ePontoExecucaoAnterior.find(valueOfPontoExecucaoAnteriorId());
        }
        return ePontoExecucaoAnterior;
    }
    
    /**
     * Ativa o join desta entidade com PONTO_PLANO_EXECUCAO
     * através do atributo PONTO_EXECUCAO_ANTERIOR_ID
     */
    public EntPontoPlanoExecucao joinPontoExecucaoAnterior() {
        return joinPontoExecucaoAnterior(null);
    }
    public EntPontoPlanoExecucao joinPontoExecucaoAnterior(String alias) {
        EntPontoPlanoExecucao entity = new EntPontoPlanoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPontoExecucaoAnteriorId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPontoExecucaoAnterior(long id, String sqlAppend) throws AdsException {
        find("select ID from PONTO_PLANO_EXECUCAO where PONTO_EXECUCAO_ANTERIOR_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPontoExecucaoAnterior(long id) throws AdsException {
        findByPontoExecucaoAnterior(id,"");
    }
    
    public void findByPontoExecucaoAnterior(Entity entidade) throws AdsException {
        findByPontoExecucaoAnterior(entidade.valueOfId(),"");
    }
    
    public void findByPontoExecucaoAnterior(Entity entidade, String sqlAppend) throws AdsException {
        findByPontoExecucaoAnterior(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPlanoExecucao ePlanoExecucao;
    
    public EntPlanoExecucao findPlanoExecucao() throws AdsException {
        if (getPlanoExecucaoId().isNull()) {
            return null;
        }
        if (ePlanoExecucao == null || !valueOfPlanoExecucaoId().equals(ePlanoExecucao.valueOfId())) {
            ePlanoExecucao = new EntPlanoExecucao(ctx);
            ePlanoExecucao.find(valueOfPlanoExecucaoId());
        }
        return ePlanoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PLANO_EXECUCAO
     * através do atributo PLANO_EXECUCAO_ID
     */
    public EntPlanoExecucao joinPlanoExecucao() {
        return joinPlanoExecucao(null);
    }
    public EntPlanoExecucao joinPlanoExecucao(String alias) {
        EntPlanoExecucao entity = new EntPlanoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPlanoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPlanoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from PONTO_PLANO_EXECUCAO where PLANO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPlanoExecucao(long id) throws AdsException {
        findByPlanoExecucao(id,"");
    }
    
    public void findByPlanoExecucao(Entity entidade) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPlanoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eFormulaCalcularVazao = null;
        ePontoExecucao = null;
        ePontoExecucaoAnterior = null;
        ePlanoExecucao = null;
    }
    /**
     * Retorna os registros de REGRA_VARIAVEL_PLANO_EXECUCAO que referenciam este registro através do atributo PONTO_PLANO_EXECUCAO_ID
     */
    public EntRegraVariavelPlanoExecucao findAllRegraVariavelPlanoExecucaoPontoPlanoExecucao() throws AdsException {
        return findAllRegraVariavelPlanoExecucaoPontoPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de REGRA_VARIAVEL_PLANO_EXECUCAO que referenciam este registro através do atributo PONTO_PLANO_EXECUCAO_ID
     */
    public EntRegraVariavelPlanoExecucao findAllRegraVariavelPlanoExecucaoPontoPlanoExecucao(String sqlAppend) throws AdsException {
        EntRegraVariavelPlanoExecucao out = new EntRegraVariavelPlanoExecucao(ctx);
        out.find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where PONTO_PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo PONTO_PLANO_EXECUCAO_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioPontoPlanoExecucao() throws AdsException {
        return findAllValorVariavelEnsaioPontoPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo PONTO_PLANO_EXECUCAO_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioPontoPlanoExecucao(String sqlAppend) throws AdsException {
        EntValorVariavelEnsaio out = new EntValorVariavelEnsaio(ctx);
        out.find("select ID from VALOR_VARIAVEL_ENSAIO where PONTO_PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de PONTO_PLANO_EXECUCAO que referenciam este registro através do atributo PONTO_EXECUCAO_ANTERIOR_ID
     */
    public EntPontoPlanoExecucao findAllPontoPlanoExecucaoPontoExecucaoAnterior() throws AdsException {
        return findAllPontoPlanoExecucaoPontoExecucaoAnterior("order by ID");
    }
    
    /**
     * Retorna os registros de PONTO_PLANO_EXECUCAO que referenciam este registro através do atributo PONTO_EXECUCAO_ANTERIOR_ID
     */
    public EntPontoPlanoExecucao findAllPontoPlanoExecucaoPontoExecucaoAnterior(String sqlAppend) throws AdsException {
        EntPontoPlanoExecucao out = new EntPontoPlanoExecucao(ctx);
        out.find("select ID from PONTO_PLANO_EXECUCAO where PONTO_EXECUCAO_ANTERIOR_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oSequencia.setValue(aSequencia);
        oFormulaCalcularVazaoId.setValue(aFormulaCalcularVazaoId);
        oPontoExecucaoId.setValue(aPontoExecucaoId);
        oQuantidadeIteracoesPonto.setValue(aQuantidadeIteracoesPonto);
        oPontoExecucaoAnteriorId.setValue(aPontoExecucaoAnteriorId);
        oPlanoExecucaoId.setValue(aPlanoExecucaoId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setName("PK_PUNPEX");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setAssociatedEntity(EntFormulaExecucao.class);
            rule.setName("FK_PUNPEX_FORMULA");
            rule.addAttribute(new DomId("FORMULA_CALCULAR_VAZAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setAssociatedEntity(EntPlanoExecucao.class);
            rule.setName("FK_PUNPEX_PLANO_EXECUCAO");
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setAssociatedEntity(EntPontoPlanoExecucao.class);
            rule.setName("FK_PUNPEX_PONTO_ANTERIOR");
            rule.addAttribute(new DomId("PONTO_EXECUCAO_ANTERIOR_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setAssociatedEntity(EntPontoExecucao.class);
            rule.setName("FK_PUNPEX_PONTO_EXECUCAO");
            rule.addAttribute(new DomId("PONTO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setName("UK_PUNPEX_PONTO_PLANO");
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            rule.addAttribute(new DomId("PONTO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPontoPlanoExecucao.class);
            rule.setName("UK_PUNPEX_SEQUENCIA");
            rule.addAttribute(new DomInteger("SEQUENCIA",""));
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void posInsert() throws AdsException {
        atualizarRegrasVariaveisPlano(); //Atualizar regras de variáveis do plano
    }
    
    @Override
    protected void posUpdate() throws AdsException {
        atualizarRegrasVariaveisPlano(); //Atualizar regras de variáveis do plano
    }
    
    @Override
    protected void posDelete() throws AdsException {
        atualizarRegrasVariaveisPlano(); //Atualizar regras de variáveis do plano
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getQuantidadeIteracoesPonto().isNull()) {
            setQuantidadeIteracoesPonto(getQuantidadeIteracoesPonto().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Regra de ação: Atualizar regras de variáveis do plano
     * 
     * Se o ponto do plano é atualizar, revisar as regras de variáveis que 
     * usam ou dependem deste ponto.
     */
    private void atualizarRegrasVariaveisPlano() throws AdsException {
        // <user-code id="21163684" parentId="21163669" hashcode="-57cc017f" length="120">
        //ctx.pushError(ENTITY_NAME,
        //        Severity.WARNING,
        //        "Revisar as regras e variáveis do plano de execução.");
        // 
        // </user-code>
    }
}
